import 'package:playtruly/common/services/http.dart';
import 'package:playtruly/common/models/index.dart';
import 'package:playtruly/common/utils/encryption_util.dart';
import 'package:playtruly/common/services/rongcloud_service.dart'; // 🔥 导入融云服务
import 'package:playtruly/common/api/user_api.dart'; // 🔥 导入用户API
import 'dart:developer' as developer;
import 'dart:convert';

/// 活动相关API
class ActivityApi {
  
  /// 查询附近活动列表（使用AES加密）
  /// [latitude] 纬度（必填）
  /// [longitude] 经度（必填）
  /// [radius] 搜索半径（公里），默认50
  /// [limit] 返回数量限制，默认50
  /// [page] 页码，默认1
  /// 返回ActivityListResponse对象
  static Future<ActivityListResponse> getNearbyActivities({
    required double latitude,
    required double longitude,
    double? radius,
    int? limit,
    int? page,
  }) async {
    try {
      developer.log('🔄 =============== 开始查询附近活动（AES加密） ===============');
      developer.log('📍 位置: $latitude, $longitude');
      
      // 创建请求参数
      final requestData = {
        'latitude': latitude,
        'longitude': longitude,
        'radius': radius ?? 50.0,
        'limit': limit ?? 50,
        'page': page ?? 1,
      };

      developer.log('📊 请求参数（加密前）: $requestData');
      
      // 🔥 使用AES加密
      developer.log('🔐 开始AES加密活动查询数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      developer.log('🚀 准备发送加密请求到: /activities/nearby/');

      // 发送请求
      final response = await HttpService.to.post(
        '/activities/nearby/',
        data: encryptedPayload,
      );

      // 解析响应
      final activityResponse = ActivityListResponse.fromJson(response);

      return activityResponse;
    } catch (e) {
      // 如果出现异常，返回失败响应
      return ActivityListResponse(
        status: 'error',
        message: '查询活动列表失败: ${e.toString()}',
        data: [],
      );
    }
  }

  /// 根据当前位置查询活动列表（简化版本）
  /// 使用默认参数
  static Future<ActivityListResponse> getActivitiesNearCurrentLocation({
    required double latitude,
    required double longitude,
  }) async {
    return await getNearbyActivities(
      latitude: latitude,
      longitude: longitude,
      radius: 50.0, // 默认50公里
      limit: 20,    // 默认20个活动
    );
  }

  /// 查询活动列表（不使用加密的版本，用于兼容性）
  static Future<Map<String, dynamic>> getNearbyActivitiesLegacy({
    required double latitude,
    required double longitude,
    double? radius,
    int? limit,
  }) async {
    // 生成时间戳
    final timestamp = (DateTime.now().millisecondsSinceEpoch ~/ 1000).toString();
    
    return await HttpService.to.post(
      '/activities/nearby/',
      data: {
        'latitude': latitude,
        'longitude': longitude,
        'radius': radius ?? 50.0,
        'limit': limit ?? 50,
        'timestamp': timestamp,
      },
    );
  }

  /// 按活动类型查询活动
  static Future<List<ActivityData>> getActivitiesByType({
    required double latitude,
    required double longitude,
    required String activityType,
    double? radius,
    int? limit,
  }) async {
    try {
      final response = await getNearbyActivities(
        latitude: latitude,
        longitude: longitude,
        radius: radius,
        limit: limit,
      );

      if (response.isSuccess) {
        // 筛选指定类型的活动
        return response.filterByType(activityType);
      }
      
      return [];
    } catch (e) {
      developer.log('按类型查询活动异常: $e');
      return [];
    }
  }

  /// 按活动标签查询活动
  static Future<List<ActivityData>> getActivitiesByTag({
    required double latitude,
    required double longitude,
    required String tag,
    double? radius,
    int? limit,
  }) async {
    try {
      final response = await getNearbyActivities(
        latitude: latitude,
        longitude: longitude,
        radius: radius,
        limit: limit,
      );

      if (response.isSuccess) {
        // 筛选指定标签的活动
        return response.filterByTag(tag);
      }
      
      return [];
    } catch (e) {
      developer.log('按标签查询活动异常: $e');
      return [];
    }
  }

  /// 按距离范围查询活动
  static Future<List<ActivityData>> getActivitiesByDistance({
    required double latitude,
    required double longitude,
    required double maxDistance,
    int? limit,
  }) async {
    try {
      final response = await getNearbyActivities(
        latitude: latitude,
        longitude: longitude,
        radius: maxDistance,
        limit: limit,
      );

      if (response.isSuccess) {
        // 筛选指定距离内的活动并排序
        return response.filterByDistance(maxDistance);
      }
      
      return [];
    } catch (e) {
      developer.log('按距离查询活动异常: $e');
      return [];
    }
  }

  /// 获取正在进行的活动
  static Future<List<ActivityData>> getActiveActivities({
    required double latitude,
    required double longitude,
    double? radius,
    int? limit,
  }) async {
    try {
      final response = await getNearbyActivities(
        latitude: latitude,
        longitude: longitude,
        radius: radius,
        limit: limit,
      );

      if (response.isSuccess) {
        // 只返回正在进行的活动
        return response.activeActivities;
      }
      
      return [];
    } catch (e) {
      developer.log('查询进行中活动异常: $e');
      return [];
    }
  }

  /// 获取可参加的活动（未满员）
  static Future<List<ActivityData>> getAvailableActivities({
    required double latitude,
    required double longitude,
    double? radius,
    int? limit,
  }) async {
    try {
      final response = await getNearbyActivities(
        latitude: latitude,
        longitude: longitude,
        radius: radius,
        limit: limit,
      );

      if (response.isSuccess) {
        // 只返回未满员的活动
        return response.availableActivities;
      }
      
      return [];
    } catch (e) {
      developer.log('查询可参加活动异常: $e');
      return [];
    }
  }

  /// 获取推荐活动（距离近且活跃的）
  static Future<List<ActivityData>> getRecommendedActivities({
    required double latitude,
    required double longitude,
  }) async {
    try {
      final response = await getNearbyActivities(
        latitude: latitude,
        longitude: longitude,
        radius: 20.0, // 推荐活动限制在20公里内
        limit: 10,    // 限制10个推荐活动
      );

      if (response.isSuccess) {
        // 获取距离近且可参加的活动，按距离排序
        var availableActivities = response.availableActivities;
        availableActivities.sort((a, b) {
          if (a.distance == null && b.distance == null) return 0;
          if (a.distance == null) return 1;
          if (b.distance == null) return -1;
          return a.distance!.compareTo(b.distance!);
        });
        
        return availableActivities.take(5).toList(); // 取前5个最近的
      }
      
      return [];
    } catch (e) {
      developer.log('查询推荐活动异常: $e');
      return [];
    }
  }

  /// 发布活动（使用AES加密）
  /// [activityTitle] 活动标题（必填）
  /// [publisherId] 发布者ID（必填）
  /// [publisherNickname] 发布者昵称（必填）
  /// [activityPublishTime] 活动时间（必填）
  /// [latitude] 纬度（必填）
  /// [longitude] 经度（必填）
  /// [activityDetails] 活动详情（可选）
  /// [activityLocation] 活动地点（可选）
  /// [activityImages] 活动图片（可选）
  /// [activityType] 活动类型（可选）
  /// [activityTags] 活动标签（可选）
  /// [activityMaxParticipants] 最大参与人数（可选，默认10）
  /// [publisherAvatarUrl] 发布者头像URL（可选）
  /// [publisherSignature] 发布者签名（可选）
  /// [publisherTags] 发布者标签（可选）
  /// [free] 是否免费发布（可选，默认0）
  /// 返回发布结果
  static Future<Map<String, dynamic>> publishActivity({
    required String activityTitle,
    required int publisherId,
    required String publisherNickname,
    required String activityPublishTime,
    required double latitude,
    required double longitude,
    String? activityDetails,
    String? activityLocation,
    List<String>? activityImages,
    List<String>? activityType,
    List<String>? activityTags,
    int? activityMaxParticipants,
    String? publisherAvatarUrl,
    String? publisherSignature,
    List<String>? publisherTags,
    int? publisherPoints,
    String? activityStatusMessage,
    Map<String, dynamic>? extraData,
    int? free,
  }) async {
    try {
      developer.log('🔄 =============== 开始发布活动（AES加密） ===============');
      developer.log('🎯 活动标题: $activityTitle');
      developer.log('👤 发布者ID: $publisherId');

      // 构建请求参数
      final requestData = <String, dynamic>{
        'activityTitle': activityTitle,
        'publisherId': publisherId,
        'publisherNickname': publisherNickname,
        'activityPublishTime': activityPublishTime,
        'latitude': latitude,
        'longitude': longitude,
      };

      // 添加可选参数
      if (activityDetails != null && activityDetails.isNotEmpty) {
        requestData['activityDetails'] = activityDetails;
      }
      
      if (activityLocation != null && activityLocation.isNotEmpty) {
        requestData['activityLocation'] = activityLocation;
      }
      
      if (activityImages != null && activityImages.isNotEmpty) {
        requestData['activityImages'] = activityImages;
      }
      
      if (activityType != null && activityType.isNotEmpty) {
        requestData['activityType'] = activityType;
      }
      
      if (activityTags != null && activityTags.isNotEmpty) {
        requestData['activityTags'] = activityTags;
      }
      
      if (activityMaxParticipants != null) {
        requestData['activityMaxParticipants'] = activityMaxParticipants;
      }
      
      if (publisherAvatarUrl != null && publisherAvatarUrl.isNotEmpty) {
        requestData['publisherAvatarUrl'] = publisherAvatarUrl;
      }
      
      if (publisherSignature != null && publisherSignature.isNotEmpty) {
        requestData['publisherSignature'] = publisherSignature;
      }
      
      if (publisherTags != null && publisherTags.isNotEmpty) {
        requestData['publisherTags'] = publisherTags;
      }
      
      if (publisherPoints != null) {
        requestData['publisherPoints'] = publisherPoints;
      }
      
      if (activityStatusMessage != null && activityStatusMessage.isNotEmpty) {
        requestData['activityStatusMessage'] = activityStatusMessage;
      }
      
      if (extraData != null && extraData.isNotEmpty) {
        requestData['extraData'] = extraData;
      }
      
      if (free != null) {
        requestData['free'] = free;
      }

      developer.log('📊 请求参数（加密前）: $requestData');
      
      // 🔥 使用AES加密
      developer.log('🔐 开始AES加密活动发布数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      developer.log('🚀 准备发送加密请求到: /activities/');

      // 发送请求
      final response = await HttpService.to.post(
        '/activities/',
        data: encryptedPayload,
      );

      developer.log('📨 活动发布响应: $response');

      // 检查响应状态
      if (response is Map<String, dynamic> && response['status'] == 'success') {
        developer.log('✅ 活动发布成功: ${response['message']}');
        return {
          'success': true,
          'message': response['message'] ?? '活动发布成功',
          'activityId': response['activity_id'],
          'pointsChange': response['pointsChange'] ?? 0,
        };
      } else {
        String errorMessage = '发布失败';
        if (response is Map<String, dynamic> && response['message'] != null) {
          errorMessage = response['message'];
        }
        developer.log('❌ 活动发布失败: $errorMessage');
        return {
          'success': false,
          'message': errorMessage,
        };
      }

    } catch (e) {
      developer.log('💥 发布活动异常: $e');
      return {
        'success': false,
        'message': '发布活动失败: ${e.toString()}',
      };
    }
  }

  /// 查询活动详情（使用AES加密）
  /// [activityId] 活动ID（必填）
  /// 返回活动详情信息
  static Future<Map<String, dynamic>> getActivityDetail({
    required int activityId,
  }) async {
    try {
      developer.log('🔄 =============== 开始查询活动详情（AES加密） ===============');
      developer.log('🎯 活动ID: $activityId');

      // 构建请求参数
      final requestData = {
        'activityId': activityId,
      };

      developer.log('📊 请求参数（加密前）: $requestData');
      
      // 🔥 使用AES加密
      developer.log('🔐 开始AES加密活动详情查询数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      developer.log('🚀 准备发送加密请求到: /query/activity_user/');

      // 发送请求
      final response = await HttpService.to.post(
        '/query/activity_user/',
        data: encryptedPayload,
      );

      developer.log('📨 活动详情查询响应: $response');

      return response;
    } catch (e) {
      developer.log('💥 查询活动详情异常: $e');
      return {
        'status': 'error',
        'message': '查询活动详情失败: ${e.toString()}',
      };
    }
  }

  /// 编辑活动（使用AES加密）
  /// [activityId] 活动ID（必填）
  /// [activityTitle] 活动标题（可选）
  /// [activityDetails] 活动详情（可选）
  /// [activityLocation] 活动地点（可选）
  /// [activityImages] 活动图片（可选）
  /// [activityType] 活动类型（可选）
  /// [activityTags] 活动标签（可选）
  /// [activityMaxParticipants] 最大参与人数（可选）
  /// [activityPublishTime] 活动时间（可选）
  /// [latitude] 纬度（可选）
  /// [longitude] 经度（可选）
  /// [activityStatusMessage] 活动状态消息（可选）
  /// [extraData] 额外数据（可选）
  /// 返回编辑结果
  static Future<ActivityEditResponse> editActivity({
    required int activityId,
    String? activityTitle,
    String? activityDetails,
    String? activityLocation,
    List<String>? activityImages,
    List<String>? activityType,
    List<String>? activityTags,
    int? activityMaxParticipants,
    String? activityPublishTime,
    double? latitude,
    double? longitude,
    String? activityStatusMessage,
    Map<String, dynamic>? extraData,
  }) async {
    try {
      developer.log('🔄 =============== 开始编辑活动（AES加密） ===============');
      developer.log('🎯 活动ID: $activityId');
      if (activityTitle != null) developer.log('📝 新标题: $activityTitle');

      // 创建请求模型
      final request = ActivityEditRequest(
        activityId: activityId,
        activityTitle: activityTitle,
        activityDetails: activityDetails,
        activityLocation: activityLocation,
        activityImages: activityImages,
        activityType: activityType,
        activityTags: activityTags,
        activityMaxParticipants: activityMaxParticipants,
        activityPublishTime: activityPublishTime,
        latitude: latitude,
        longitude: longitude,
        activityStatusMessage: activityStatusMessage,
        extraData: extraData,
      );

      // 获取请求数据
      final requestData = request.toJson();
      developer.log('📊 请求参数（加密前）: $requestData');
      
      // 🔥 使用AES加密
      developer.log('🔐 开始AES加密活动编辑数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      developer.log('🚀 准备发送加密请求到: /activities/edit');

      // 发送请求
      final response = await HttpService.to.post(
        '/activities/edit',
        data: encryptedPayload,
      );

      developer.log('📨 活动编辑响应: $response');
      developer.log('📊 响应数据类型: ${response.runtimeType}');
      if (response is Map<String, dynamic>) {
        developer.log('📋 响应字段: ${response.keys.toList()}');
      }

      // 解析响应
      final editResponse = ActivityEditResponse.fromJson(response);

      if (editResponse.isSuccess) {
        developer.log('✅ 活动编辑成功: ${editResponse.message}');
      } else {
        developer.log('❌ 活动编辑失败: ${editResponse.message}');
      }

      return editResponse;
    } catch (e) {
      developer.log('💥 编辑活动异常: $e');
      return ActivityEditResponse(
        status: 'error',
        message: '编辑活动失败: ${e.toString()}',
      );
    }
  }

  /// 查询活动参与者（使用AES加密，POST方式）
  /// [activityId] 活动ID（必填）
  /// 返回活动参与者列表
  static Future<ActivityParticipantsResponse> getActivityParticipants({
    required int activityId,
  }) async {
    try {
      developer.log('🔄 =============== 开始查询活动参与者（AES加密） ===============');
      developer.log('🎯 活动ID: $activityId');

      // 创建请求模型
      final request = ActivityParticipantsRequest(
        activityId: activityId,
      );

      // 获取请求数据
      final requestData = request.toJson();
      developer.log('📊 请求参数（加密前）: $requestData');
      
      // 🔥 使用AES加密
      developer.log('🔐 开始AES加密活动参与者查询数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      developer.log('🚀 准备发送加密请求到: /activities/participants/edit');

      // 发送POST请求（加密），参考MyApplication2使用的endpoint
      final response = await HttpService.to.post(
        '/activities/participants/edit',
        data: encryptedPayload,
      );

      developer.log('📨 活动参与者查询响应: $response');

      // 解析响应
      final participantsResponse = ActivityParticipantsResponse.fromJson(response);

      if (participantsResponse.isSuccess) {
        developer.log('✅ 活动参与者查询成功');
        developer.log('👥 参与者数量: ${participantsResponse.data?.total ?? 0}');
      } else {
        developer.log('❌ 活动参与者查询失败: ${participantsResponse.message}');
      }

      return participantsResponse;
    } catch (e) {
      developer.log('💥 查询活动参与者异常: $e');
      return ActivityParticipantsResponse(
        status: 'error',
        message: '查询活动参与者失败: ${e.toString()}',
      );
    }
  }

  /// 查询发布者的活动参与者（使用AES加密）
  /// [publisherId] 发布者ID（必填）
  /// 返回发布者活动的所有参与者
  static Future<PublisherParticipantsResponse> getPublisherActivityParticipants({
    required int publisherId,
  }) async {
    try {
      developer.log('🔄 =============== 开始查询发布者活动参与者（AES加密） ===============');
      developer.log('🎯 发布者ID: $publisherId');

      // 创建请求数据（严格按照MyApplication2格式）
      final requestData = {
        'userid': publisherId.toString(), // 使用userid参数名，与MyApplication2保持一致
      };
      developer.log('📊 请求参数（加密前）: $requestData');
      
      // 🔥 使用AES加密
      developer.log('🔐 开始AES加密发布者参与者查询数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      developer.log('🚀 准备发送加密请求到: /publisher/activity/participants');

      // 发送请求
      final response = await HttpService.to.post(
        '/publisher/activity/participants',
        data: encryptedPayload,
      );

      developer.log('📨 发布者活动参与者查询响应: $response');

      // 解析响应
      final participantsResponse = PublisherParticipantsResponse.fromJson(response);

      if (participantsResponse.isSuccess) {
        developer.log('✅ 发布者活动参与者查询成功');
        developer.log('👥 参与者总数: ${participantsResponse.total}');
        developer.log('⏳ 待审核: ${participantsResponse.pendingParticipants.length}');
        developer.log('✅ 已通过: ${participantsResponse.approvedParticipants.length}');
      } else {
        developer.log('❌ 发布者活动参与者查询失败: ${participantsResponse.message}');
      }

      return participantsResponse;
    } catch (e) {
      developer.log('💥 查询发布者活动参与者异常: $e');
      return PublisherParticipantsResponse(
        status: 'error',
        message: '查询发布者活动参与者失败: ${e.toString()}',
        participants: [],
        total: 0,
      );
    }
  }

  /// 审核活动参与者申请（使用AES加密）
  /// [activityId] 活动ID（必填）
  /// [userId] 用户ID（必填）
  /// [reviewStatus] 审核状态：'approved'（通过）或'rejected'（拒绝）（必填）
  /// [reviewNote] 审核备注（可选）
  /// 返回审核结果
  static Future<ParticipantReviewResponse> reviewParticipantApplication({
    required int activityId,
    required int userId,
    required String reviewStatus,
    String? reviewNote,
  }) async {
    try {
      developer.log('🔄 =============== 开始审核参与者申请（AES加密） ===============');
      developer.log('🎯 活动ID: $activityId, 用户ID: $userId');
      developer.log('📝 审核状态: $reviewStatus');
      if (reviewNote != null) developer.log('💬 审核备注: $reviewNote');

      // 创建请求模型
      final request = ParticipantReviewRequest(
        activityId: activityId,
        userId: userId,
        reviewStatus: reviewStatus,
        reviewNote: reviewNote,
        timestamp: (DateTime.now().millisecondsSinceEpoch ~/ 1000).toString(),
      );

      // 获取请求数据
      final requestData = request.toJson();
      developer.log('📊 请求参数（加密前）: $requestData');
      
      // 🔥 使用AES加密
      developer.log('🔐 开始AES加密审核数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      developer.log('🚀 准备发送加密请求到: /activities/participants/review');

      // 发送请求
      final response = await HttpService.to.post(
        '/activities/participants/review',
        data: encryptedPayload,
      );

      developer.log('📨 参与者申请审核响应: $response');

      // 解析响应
      final reviewResponse = ParticipantReviewResponse.fromJson(response);

      if (reviewResponse.isSuccess) {
        // 🎯 根据原始操作状态判断，而不是依赖服务器返回的review_status字段
        final statusText = reviewStatus == 'approved' ? '通过' : '拒绝';
        developer.log('✅ 参与者申请审核成功: $statusText');
      } else {
        developer.log('❌ 参与者申请审核失败: ${reviewResponse.message}');
      }

      return reviewResponse;
    } catch (e) {
      developer.log('💥 审核参与者申请异常: $e');
      return ParticipantReviewResponse(
        status: 'error',
        message: '审核参与者申请失败: ${e.toString()}',
      );
    }
  }

  /// 加入活动（使用AES加密，参考MyApplication2项目简化实现）
  /// [activityId] 活动ID（必填）
  /// [userId] 用户ID（必填）
  /// 返回加入活动结果
  static Future<JoinActivityResponse> joinActivity({
    required int activityId,
    required int userId,
    String? userNickname, // 保持兼容性，但不传递给服务器
    String? userAvatarUrl, // 保持兼容性，但不传递给服务器
    String? userSignature, // 保持兼容性，但不传递给服务器
    List<String>? userTags, // 保持兼容性，但不传递给服务器
    int? userPoints, // 保持兼容性，但不传递给服务器
    String? participantStatus, // 🔥 修复：现在会传递给服务器，默认为'待审核'
    Map<String, dynamic>? extraData, // 保持兼容性，但不传递给服务器
  }) async {
    try {
      developer.log('🔄 =============== 开始加入活动（简化版AES加密，参考MyApplication2） ===============');
      developer.log('🎯 活动ID: $activityId');
      developer.log('👤 用户ID: $userId');

      // 🎯 修复：参考MyApplication2项目，传递完整的参数（包含participantStatus）
      final requestData = <String, dynamic>{
        'activityId': activityId,
        'userId': userId,
        'participantStatus': participantStatus ?? '待审核', // 🔥 修复：添加参与者状态到请求中
        'timestamp': DateTime.now().millisecondsSinceEpoch ~/ 1000, // 添加时间戳
      };

      developer.log('📊 请求参数（加密前，参考MyApplication2）: $requestData');
      developer.log('📝 原始数据: ${requestData.toString()}');
      
      // 🔥 使用AES加密
      developer.log('🔐 开始AES加密加入活动数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      developer.log('🚀 准备发送加密请求到: /activities/participants/');

      // 发送请求（根据MyApplication2项目，使用POST /activities/participants/，末尾加斜杠避免307重定向）
      final response = await HttpService.to.post(
        '/activities/participants/',
        data: encryptedPayload,
      );

      developer.log('📨 加入活动响应: $response');
      developer.log('📊 响应数据类型: ${response.runtimeType}');

      // 🔧 改进响应解析逻辑，处理可能的字符串响应或空响应
      Map<String, dynamic> responseData;
      
      if (response is Map<String, dynamic>) {
        responseData = response;
        developer.log('✅ 响应是JSON对象');
      } else if (response is String) {
        developer.log('⚠️ 响应是字符串，尝试解析为JSON');
        try {
          final decoded = json.decode(response);
          if (decoded is Map<String, dynamic>) {
            responseData = decoded;
          } else {
            // 如果不是JSON对象，创建默认响应
            responseData = {
              'status': 'success', // 假设字符串响应表示成功
              'message': response.toString(),
            };
          }
        } catch (e) {
          developer.log('❌ JSON解析失败，创建默认响应: $e');
          responseData = {
            'status': 'success', // 假设成功
            'message': response.toString(),
          };
        }
      } else {
        developer.log('⚠️ 响应类型未知，创建默认响应');
        responseData = {
          'status': 'success',
          'message': response?.toString() ?? '请求成功',
        };
      }

      // 解析响应
      final joinResponse = JoinActivityResponse.fromJson(responseData);

      if (joinResponse.isSuccess) {
        developer.log('✅ 加入活动成功: ${joinResponse.message}');
      } else {
        developer.log('❌ 加入活动失败: ${joinResponse.message}');
      }

      return joinResponse;
    } catch (e) {
      developer.log('💥 加入活动异常: $e');
      return JoinActivityResponse(
        status: 'error',
        message: '加入活动失败: ${e.toString()}',
      );
    }
  }

  /// 删除活动参与者（使用AES加密）
  /// [activityId] 活动ID（必填）
  /// [userId] 用户ID（必填）
  /// 返回删除结果
  static Future<DeleteParticipantResponse> deleteActivityParticipant({
    required int activityId,
    required int userId,
  }) async {
    try {
      developer.log('🔄 =============== 开始删除活动参与者（AES加密） ===============');
      developer.log('🎯 活动ID: $activityId, 用户ID: $userId');

      // 创建请求模型
      final request = DeleteParticipantRequest(
        activityId: activityId,
        userId: userId,
      );

      // 获取请求数据
      final requestData = request.toJson();
      developer.log('📊 请求参数（加密前）: $requestData');
      
      // 🔥 使用AES加密
      developer.log('🔐 开始AES加密删除参与者数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      developer.log('🚀 准备发送加密请求到: /activities/participants/delete');

      // 发送请求
      final response = await HttpService.to.post(
        '/activities/participants/delete',
        data: encryptedPayload,
      );

      developer.log('📨 删除参与者响应: $response');

      // 解析响应
      final deleteResponse = DeleteParticipantResponse.fromJson(response);

      if (deleteResponse.isSuccess) {
        developer.log('✅ 删除参与者成功: ${deleteResponse.message}');
      } else {
        developer.log('❌ 删除参与者失败: ${deleteResponse.message}');
      }

      return deleteResponse;
    } catch (e) {
      developer.log('💥 删除参与者异常: $e');
      return DeleteParticipantResponse(
        status: 'error',
        message: '删除参与者失败: ${e.toString()}',
      );
    }
  }

  /// 举报活动（使用AES加密）
  /// [reporterId] 举报者ID（必填）
  /// [reportedUserId] 被举报用户ID（可选）
  /// [reportedContentId] 被举报内容ID（可选，如活动ID）
  /// [reportType] 举报类型（必填）
  /// [reportReason] 举报原因（必填）
  /// [description] 详细描述（可选）
  /// 返回举报结果
  static Future<Map<String, dynamic>> reportActivity({
    required int reporterId,
    int? reportedUserId,
    int? reportedContentId,
    required String reportType,
    required String reportReason,
    String? description,
  }) async {
    try {
      developer.log('🔄 =============== 开始举报活动（AES加密） ===============');
      developer.log('🎯 举报者ID: $reporterId');
      developer.log('🎯 被举报用户ID: $reportedUserId');
      developer.log('🎯 被举报内容ID: $reportedContentId');
      developer.log('🎯 举报类型: $reportType');

      // 构建请求参数
      final requestData = <String, dynamic>{
        'reporter_id': reporterId,
        'report_type': reportType,
        'report_reason': reportReason,
      };

      // 添加可选参数
      if (reportedUserId != null) {
        requestData['reported_user_id'] = reportedUserId;
      }
      
      if (reportedContentId != null) {
        requestData['reported_content_id'] = reportedContentId;
      }
      
      if (description != null && description.isNotEmpty) {
        requestData['description'] = description;
      }

      developer.log('📊 请求参数（加密前）: $requestData');
      
      // 🔥 使用AES加密
      developer.log('🔐 开始AES加密举报数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      developer.log('🚀 准备发送加密请求到: /reports/create/');

      // 发送请求
      final response = await HttpService.to.post(
        '/reports/create/',
        data: encryptedPayload,
      );

      developer.log('📨 举报响应: $response');

      // 检查响应状态
      if (response is Map<String, dynamic> && response['status'] == 'success') {
        developer.log('✅ 举报提交成功: ${response['message']}');
        return {
          'success': true,
          'message': response['message'] ?? '举报提交成功',
        };
      } else {
        String errorMessage = '举报提交失败';
        if (response is Map<String, dynamic> && response['message'] != null) {
          errorMessage = response['message'];
        }
        developer.log('❌ 举报提交失败: $errorMessage');
        return {
          'success': false,
          'message': errorMessage,
        };
      }

    } catch (e) {
      developer.log('💥 举报活动异常: $e');
      return {
        'success': false,
        'message': '举报提交失败: ${e.toString()}',
      };
    }
  }

  /// ⚠️ 【已弃用】获取用户内容（使用AES加密）
  /// ❌ 此方法与UserApi.getUserContent重复，请使用UserApi.getUserContent替代
  /// [userId] 用户ID（必填）
  /// [days] 天数过滤（可选）
  /// 返回用户的活动、评论、参与活动等内容
  @Deprecated('请使用UserApi.getUserContent替代此方法，避免重复调用')
  static Future<UserContentResponse> getUserContent({
    required int userId,
    int? days,
  }) async {
    try {
      developer.log('🔄 =============== 开始获取用户内容（AES加密） ===============');
      developer.log('🎯 用户ID: $userId');

      // 创建请求模型
      final request = UserContentRequest(
        userId: userId,
        days: days,
      );

      // 获取请求数据
      final requestData = request.toJson();
      developer.log('📊 请求参数（加密前）: $requestData');
      
      // 🔥 使用AES加密
      developer.log('🔐 开始AES加密用户内容查询数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      developer.log('🚀 准备发送加密请求到: /users/content/');

      // 发送POST请求（加密）
      final response = await HttpService.to.post(
        '/users/content/',
        data: encryptedPayload,
      );

      developer.log('📨 用户内容查询响应: $response');

      // 解析响应
      final userContentResponse = UserContentResponse.fromJson(response);

      if (userContentResponse.isSuccess) {
        developer.log('✅ 用户内容查询成功');
        developer.log('📊 活动数量: ${userContentResponse.activities.length}');
        developer.log('📊 已结束活动数量: ${userContentResponse.endedActivities.length}');
        developer.log('📊 评论数量: ${userContentResponse.comments.length}');
        developer.log('📊 参与活动数量: ${userContentResponse.participatedActivities.length}');
        developer.log('📊 统计信息: ${userContentResponse.contentStats}');
      } else {
        developer.log('❌ 用户内容查询失败: ${userContentResponse.message ?? "未知错误"}');
      }

      return userContentResponse;
    } catch (e) {
      developer.log('💥 获取用户内容异常: $e');
      return UserContentResponse(
        status: 'error',
        message: '获取用户内容失败: ${e.toString()}',
        activities: [],
        endedActivities: [],
        comments: [],
        participatedActivities: [],
      );
    }
  }

  /// 删除活动（软删除 - 设置状态为"删除"，使用AES加密）
  /// 参考MyApplication2项目实现：通过修改activityStatus为["删除"]来实现软删除
  /// [activityId] 活动ID（必填）
  /// [userId] 用户ID（必填，用于权限验证）
  /// 返回删除结果
  static Future<Map<String, dynamic>> deleteActivity({
    required int activityId,
    required int userId,
  }) async {
    try {
      developer.log('🔄 =============== 开始删除活动（AES加密软删除） ===============');
      developer.log('🎯 活动ID: $activityId');
      developer.log('👤 用户ID: $userId');

      // 构建请求参数（参考MyApplication2的实现）
      final requestData = <String, dynamic>{
        'activityId': activityId.toString(), // 转为字符串，与Android版本保持一致
        'activityStatus': ['删除'], // 🎯 关键：设置状态为"删除"实现软删除
        'timestamp': (DateTime.now().millisecondsSinceEpoch ~/ 1000).toString(), // 添加时间戳
      };

      developer.log('📊 请求参数（加密前）: $requestData');
      developer.log('🎯 删除方式: 软删除（状态设置为"删除"）');
      
      // 🔥 使用AES加密
      developer.log('🔐 开始AES加密活动删除数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      developer.log('🚀 准备发送加密请求到: /activities/edit');

      // 发送请求到编辑接口（使用编辑接口来修改状态实现软删除）
      // 根据307重定向错误，服务器期望不带末尾斜杠的URL
      final response = await HttpService.to.post(
        '/activities/edit',
        data: encryptedPayload,
      );

      developer.log('📨 活动删除响应: $response');

      // 检查响应状态
      if (response is Map<String, dynamic> && response['status'] == 'success') {
        developer.log('✅ 活动删除成功: ${response['message']}');
        return {
          'success': true,
          'status': 'success',
          'message': response['message'] ?? '活动已删除',
          'activityId': activityId,
        };
      } else {
        String errorMessage = '删除失败';
        if (response is Map<String, dynamic> && response['message'] != null) {
          errorMessage = response['message'];
        }
        developer.log('❌ 活动删除失败: $errorMessage');
        return {
          'success': false,
          'status': 'error',
          'message': errorMessage,
        };
      }

    } catch (e) {
      developer.log('💥 删除活动异常: $e');
      return {
        'success': false,
        'status': 'error',
        'message': '删除活动失败: ${e.toString()}',
      };
    }
  }

  /// 🔥 统一处理：发送融云活动申请推送消息
  /// [activityId] 活动ID
  /// [activityTitle] 活动标题
  /// [activityPublisherId] 活动发布者用户ID
  /// [applicantUserId] 申请者用户ID
  /// [applicantUserName] 申请者用户名
  static Future<void> sendRongCloudActivityRequestPush({
    required int activityId,
    required String activityTitle,
    required int activityPublisherId,
    required int applicantUserId,
    required String applicantUserName,
  }) async {
    try {
      developer.log('📤 =============== 统一融云活动申请推送开始 ===============');
      developer.log('🎯 活动ID: $activityId');
      developer.log('📝 活动标题: $activityTitle');
      developer.log('👤 活动发布者ID: $activityPublisherId');
      developer.log('👤 申请者ID: $applicantUserId');
      developer.log('👤 申请者姓名: $applicantUserName');
      
      // 🔥 获取活动发布者的融云用户ID（通常是手机号）
      String? publisherRongCloudUserId;
      
      try {
        developer.log('🔍 尝试通过API获取活动发布者手机号...');
        final userInfoResponse = await UserApi.getUserFilteredContent(
          userId: activityPublisherId,
          contentType: 'activities', // 随便传一个内容类型，我们只需要用户信息
        );
        if (userInfoResponse.isSuccess && userInfoResponse.user != null) {
          publisherRongCloudUserId = userInfoResponse.user!.userPhone;
          developer.log('📱 通过API获取活动发布者手机号: $publisherRongCloudUserId');
        }
      } catch (apiError) {
        developer.log('⚠️ 获取活动发布者信息异常: $apiError');
      }
      
      // 验证融云用户ID
      if (publisherRongCloudUserId == null || publisherRongCloudUserId.isEmpty) {
        developer.log('❌ 无法获取活动发布者的融云用户ID（手机号），跳过融云推送');
        return;
      }
      
      if (publisherRongCloudUserId.length != 11 || !publisherRongCloudUserId.startsWith(RegExp(r'1[3-9]'))) {
        developer.log('⚠️ 活动发布者融云用户ID格式异常: $publisherRongCloudUserId，跳过融云推送');
        return;
      }
      
      developer.log('✅ 活动发布者融云用户ID验证通过: $publisherRongCloudUserId');
      
      // 调用融云服务发送活动申请推送
      final rongCloudSuccess = await RongCloudService.to.sendActivityRequestMessage(
        targetUserId: publisherRongCloudUserId,
        activityTitle: activityTitle,
        userName: applicantUserName,
      );
      
      if (rongCloudSuccess) {
        developer.log('✅ 统一融云活动申请推送发送成功');
      } else {
        developer.log('❌ 统一融云活动申请推送发送失败');
      }
      
      developer.log('📤 =============== 统一融云活动申请推送结束 ===============');
      
    } catch (e) {
      developer.log('💥 发送融云活动申请推送异常: $e');
      // 融云推送失败不影响主流程，只记录日志
    }
  }
}
